home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / DIconLib.cpp < prev    next >
Text File  |  1996-07-05  |  15KB  |  645 lines
  1. // DIconLib.cp
  2.  
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DIconLib.h"
  7. #include "DApplication.h"
  8. #include "DList.h"
  9. #include "DFile.h"
  10. #include <stdio.h>
  11.  
  12. typedef    unsigned char    byte;
  13. enum  BitFormat            { macbits, msbits, xbits };
  14. enum  BitmapFormat     { unknown, xbitmapfile, maciconrezfile};
  15.  
  16. DIconList* gIconList = NULL;
  17.  
  18. class DIconGlobals {
  19. public:
  20.    DIconGlobals() { gIconList = new DIconList(); }
  21. };
  22.  
  23. static DIconGlobals    globals; // initializes globals here
  24.  
  25. // Unix CC and gcc have problems linking DIcon.o w/ only data
  26. // change this to DIcons.h ??
  27. #ifdef OS_UNIX
  28. #ifdef OS_UNIX_IRIX
  29. #include "DIcons.c++"
  30. #else
  31. #include "DIcons.cc"
  32. #endif
  33. #endif
  34.  
  35. #ifdef OS_UNIX_OSF1
  36. #define StrPosInt unsigned int
  37. #else
  38. #define StrPosInt Nlm_Uint4
  39. #endif
  40.  
  41.  
  42. #if 0
  43. static unsigned short testicons[] = {
  44.     22213, 0, 13, 13, 12,
  45.  0xff00, 0x8180, 0x81c0, 0x9040, 0xa840, 0xa840, 0x9240, 0x8240,
  46.  0x8240, 0x8240, 0x8040, 0xffc0 
  47. ,
  48.   1215, 0, 32, 32, 64,
  49.  0x1fff, 0xfc00, 0x1000,  0x600, 0x13a0,  0x500, 0x13a0,  0x480,
  50.  0x13a8, 0x2440, 0x13a0,  0x420, 0x13a0, 0xe7f0, 0x13a1, 0x1010,
  51.  0x13a2,  0x810, 0x13a2,  0x810, 0x13aa,  0x890, 0x13a1, 0x1010,
  52.  0x13e0, 0xe010, 0x1220,   0x10, 0x1220,   0x10, 0x1220,   0x10,
  53.  0x122b, 0xfe90, 0x1222,  0x210, 0x11c2,  0x210, 0x1322, 0x1fd0,
  54.  0x1322, 0x1050, 0x1212, 0x1050, 0x121b, 0xf250, 0x1210, 0x1050,
  55.  0x1230, 0x1050, 0x1120, 0x1fd0, 0x11a0,   0x10, 0x10e0,   0x10,
  56.  0x1230, 0x2090, 0x1000,   0x10, 0x1000,   0x10, 0x1fff, 0xfff0
  57. ,
  58.   0,0,0,0,0,0 
  59. };
  60. #endif
  61.  
  62. static Boolean gByteFlipMade = false;
  63.  
  64. #ifdef NOTNOW_WIN_MOTIF
  65.  
  66. static byte    XByteFlip [256];
  67.  
  68. void MakeXByteFlip()
  69. {
  70.     short i, j;
  71.   byte val, inv;
  72.  
  73.   for (i = 0; i < 256; i++) {
  74.     inv = 0;
  75.     val = (byte) i;
  76.     for (j = 0; j < 8; j++) {
  77.       inv = (inv << 1);
  78.       inv += (val % 2);
  79.       val = (val >> 1);
  80.     }
  81.     XByteFlip[i] = inv;
  82.   }
  83.   gByteFlipMade= true;
  84. }
  85.  
  86. #else
  87.  
  88. void  MakeXByteFlip()
  89. {
  90.   gByteFlipMade= true;
  91. }
  92. #endif
  93.  
  94.  
  95. void DIconList::WriteAsCode( char* filename) 
  96. {
  97.     if (!filename) 
  98.         filename= (char*) gFileManager->GetOutputFileName("icons.c");
  99.     if (filename) {
  100.         long i, n= this->GetSize();
  101.         char *sbreak= ",\n";
  102.         DFile  iconf( filename, "w", "TEXT", "MMCC");
  103.         iconf.Open();
  104.         char buf[128];
  105.         sprintf(buf, "static unsigned short iconlist[] = { /* %d icons */ {\n", n);
  106.         iconf.WriteLine(buf);
  107.         for (i=0; i<n; i++) {
  108.             DIcon* ic= (DIcon*)IconAt(i);
  109.             ic->WriteCode( &iconf);
  110.             if (i == n-1) sbreak= ",\n 0, 0, 0, 0, 0, 0\n};\n";
  111.             iconf.WriteLine( sbreak );
  112.             }
  113.         iconf.Close();
  114.         }
  115. }
  116.  
  117. void DIcon::WriteCode( DFile* iconf)
  118. {
  119.     short i, nwords= 1 + ((fBitmapSize-1) / sizeof(short) );
  120.     char buf[512];
  121.     
  122.     sprintf( buf, " %d, %d, %d, %d, %d,\n", 
  123.                         fId, fSmall, fWidth, fHeight, nwords );
  124.     iconf->WriteLine( buf);
  125.     unsigned short *w = (unsigned short*) fBitmap;
  126.     char comma= ',';
  127.     for (i=0; i<nwords; i++) {
  128.         Boolean last= (i == nwords-1);
  129.         Boolean newline= (i % 8 == 7) || last;
  130.         if (last) comma= ' ';
  131.         sprintf( buf, " %#6x%c", *w, comma);
  132.         iconf->WriteLine( buf, newline);
  133.         w++;
  134.         }
  135.      
  136. }
  137.  
  138.  
  139. //class DIcon : public DObject
  140.  
  141. DIcon::DIcon() :
  142.     DObject(),
  143.     fId(0), fWidth(0), fHeight(0), fSmall(false),
  144.     fBitmapSize(0), fBitmap(NULL)
  145. { 
  146. }
  147.     
  148. DIcon::DIcon( long id, short width, short height, const char* bitmap, long bitmapsize) : 
  149.     DObject(),
  150.     fId(id), fWidth(width), fHeight(height),fSmall(false),
  151.     fBitmapSize(bitmapsize), fBitmap(NULL)
  152. {
  153.     Install( width, height, bitmap, bitmapsize);
  154. }
  155.  
  156. DIcon::DIcon( IconStore* store) :
  157.     DObject(), fBitmapSize(0), fBitmap(NULL)
  158. {
  159.     Install( -(store->width), store->height, (char*) &(store->bitmap), 
  160.                      store->bitmapsize * sizeof(short));
  161.     fId= store->id;
  162.     fSmall= store->smalli;
  163.     if (gIconList) gIconList->InsertLast( this);
  164. }
  165.  
  166.     
  167. DIcon::~DIcon() 
  168. { 
  169.     fBitmap= (char*)Nlm_MemFree(fBitmap); 
  170. }
  171.  
  172.  
  173. void DIcon::Draw(Nlm_RecT area)
  174. {
  175.     area.right  = Min( area.right, area.left + fWidth);
  176.     area.bottom = Min( area.bottom, area.top + fHeight);
  177.     Nlm_CopyBits( &area, fBitmap);
  178. }
  179.         
  180. void DIcon::Install( short width, short height, const char* bitmap, long bitmapsize) 
  181. {
  182.   Boolean flipbyte= (width<0);
  183.   if (flipbyte) width = -width;
  184.  
  185.     fWidth = width;
  186.     fHeight= height;
  187.     if (fBitmap) fBitmap= (char*)Nlm_MemFree(fBitmap);
  188.     fBitmapSize= 0;
  189.  
  190.     if (bitmap) {        
  191.         fBitmapSize = bitmapsize;
  192.         if ((fBitmap = (char*) Nlm_MemGet(fBitmapSize+2, FALSE)) != NULL) {
  193.  
  194. #ifdef IS_LITTLE_ENDIAN
  195. // damn, really I should just revise the compiled data form to use bytes instead of words
  196. // this is just a word little/big endian problem....
  197. //#if defined(WIN_MOTIF) || defined(WIN_MSWIN)
  198.        if (flipbyte) {
  199.          byte *storebyte, *bp, *bpend;
  200.          //if (!gByteFlipMade) MakeXByteFlip();  
  201.          storebyte= (byte*) fBitmap;
  202.          bp = (byte*) bitmap;
  203.          bpend= bp + bitmapsize;
  204.          while (bp < bpend) { 
  205.                  *storebyte++= bp[1];
  206.                  *storebyte++= bp[0];
  207.                  bp += 2;
  208.                     }
  209.          }
  210.        else
  211. #endif
  212.                 Nlm_MemCpy (fBitmap, bitmap, fBitmapSize); // +1 bad for mswin?
  213.                 fBitmap[fBitmapSize]= 0;
  214.             }
  215.         }
  216. } 
  217.  
  218.  
  219.  
  220.  
  221. //class DIconList : public DList
  222.  
  223. DIconList::DIconList()
  224. {
  225. }
  226.  
  227.  
  228. DIcon* DIconList::IconById(long id) 
  229. {
  230.     if (id) {
  231.         long i, n= this->GetSize();
  232.         for (i= 0; i<n; i++) {
  233.             if (IconAt(i)->fId == id) return IconAt(i);
  234.             }
  235.     }
  236.     return NULL;
  237. }
  238.  
  239. void DIconList::StoreFromCode( unsigned short* ilist, short nlist) 
  240. {
  241.     Boolean notdone;
  242.     IconStore* store;
  243.     unsigned short* next;
  244.     short i= 0;
  245.     
  246.     store= (IconStore*) ilist;    
  247.     notdone= (store->bitmapsize) && (nlist==0 || (i<nlist));
  248.     while (notdone) {
  249.         next= ilist + sizeof(IconStore) + (store->bitmapsize - 1) * sizeof(short);
  250.         DIcon* ic= new DIcon( store);
  251.         this->InsertLast( ic);
  252.         i++;
  253.         ilist= next;
  254.         store= (IconStore*) ilist;
  255.         notdone= (store->bitmapsize) && (nlist==0 || (i<nlist));
  256.         }
  257. }
  258.  
  259.  
  260. void DIconList::ReadAppIcons() 
  261. {
  262. #ifdef OS_DOS
  263.   char *suffix = ".icn"; // ?? or ".ico", which is also MSWin own format
  264. #else
  265.   char *suffix = ".icons";
  266. #endif
  267.     char *iconfile = NULL;
  268.  
  269.   //MakeXByteFlip();
  270.     long len= StrLen(  (char*)gApplication->Shortname()) + StrLen(suffix);
  271.     iconfile= (char*) MemNew(len+2);
  272.     StrCpy(iconfile, (char*)gApplication->Shortname());
  273.     StrCat(iconfile, suffix);
  274.     this->Read(iconfile);
  275.     Nlm_MemFree(iconfile);
  276. }
  277.     
  278.     
  279.  
  280.  
  281. Boolean DIconList::Read(char* filename) 
  282. {
  283.     BitmapFormat    fileformat= unknown;
  284.     FILE *f= FileOpen( filename, "r");
  285.     if (f) {
  286.         char line[512];
  287.         Boolean more= true;
  288.         short    atline = 0;
  289.         while (more && FileGets( line, 512, f)) {
  290.             StrPosInt index = 0;
  291.             atline++;
  292.  
  293.             if (Nlm_StrngPos(line, "char ", 0, true, &index)  
  294.             || Nlm_StrngPos(line, "static ", 0, true, &index)) {
  295.                 fileformat= xbitmapfile;    
  296.                 more= false;
  297.                 }
  298.                 
  299.             else if (Nlm_StrngPos(line, "resource ", 0, true, &index))  {
  300.                 fileformat= maciconrezfile;    
  301.                 more= false;
  302.                 }
  303.             
  304.             if (atline > 50) more= false;        
  305.             }
  306.         }
  307.     FileClose( f);
  308.     
  309.     switch (fileformat) {
  310.         case xbitmapfile        : return this->ReadXbitmapFormat( filename);
  311.         case maciconrezfile    : return this->ReadMacRezFormat( filename);
  312.         default                            : return false;
  313.         }
  314.         
  315. }
  316.  
  317.  
  318.  
  319. Boolean DIconList::ReadMacRezFormat(char* filename) 
  320. {
  321. /******
  322. mac rez file format:
  323. resource 'ICN#' (128, "Calc Family", purgeable) {
  324. {    $"..."
  325.     $"...",
  326.     // icon mask 
  327.     $"..."
  328.     $"..."
  329.   }
  330. };
  331.  
  332. resource 'ics#' (128, "Calc Family", purgeable) {
  333. };
  334.  
  335. resource 'ICON' (kSeedIconId, purgeable) {
  336.     $"0001 0000 0002 8000 0004 4000 0008 2000 0010 1000 0020 0800 0040 0400 0080 0200"
  337.     $"0100 0100 0200 0080 0400 0040 0800 0020 1000 0010 2000 0008 4000 3F04 8000 4082"
  338.     $"4000 8041 2001 3022 1001 C814 080E 7F8F 0402 3007 0201 0007 0100 8007 0080 6007"
  339.     $"0040 1FE7 0020 021F 0010 0407 0008 0800 0004 1000 0002 2000 0001 4000 0000 8000"
  340. };
  341. ******/
  342.  
  343.     const    short    bufsize = 512;
  344.     char  line[512];
  345.     byte    buf[bufsize];
  346.     byte *bitsp= NULL, *bitmap = NULL;
  347.     Boolean inbits= false, instring= false;
  348.     short    width = 0, height = 0;
  349.     long     id = 0;
  350.     char* linep= line;
  351.     long     bytesize= 0;
  352.     long     atsize= 0;
  353.     Boolean gotdata= false;
  354.     StrPosInt index;
  355.  
  356.     FILE *f= FileOpen( filename, "r");
  357.     if (f) 
  358.      while (FileGets( line, 512, f)) {
  359.         // assume may be multiple bitmaps / file
  360.         linep= line;
  361.         
  362.         if (inbits) {
  363.     suckbits:            
  364.     
  365.                 // here we must watch for 
  366.                 //    "$" == flag for hex data following
  367.                 //    '"' == start/end of string data
  368.                 //    ',' == end of one icon, another follows ?? we only get 1st & ingore mask?
  369.                 //    '}' ';' == end of resource
  370.                 
  371.             char ec, *ep;
  372.             char *cp= linep;
  373.             unsigned short card;
  374.             short rslt;
  375.             
  376.             if (!atsize || !bitsp) {
  377.                 bitsp= buf;
  378.                 atsize= 0;
  379.                 }
  380.                 
  381.             while (*cp) {
  382.             
  383.                 if (instring) {
  384.                     short ic;
  385.                     while (*cp && !isalnum(*cp)) cp++;
  386.                     for (ic= 0, ep= cp; 
  387.                         ic<2 && (*ep) && isalnum(*ep); 
  388.                         ep++, ic++) ;
  389.                     ec= *ep; *ep= 0; card= 0;
  390.                     rslt= sscanf( cp, "%hx", &card);
  391.                     *ep= ec;
  392.                     if ( atsize<bufsize && rslt>0 ) { 
  393.                         *bitsp++ = (byte) card;
  394.                         atsize++;
  395.                         }
  396.                     cp = ep;
  397.                     }    
  398.                 else
  399.                     cp++;
  400.                     
  401.                 if (*cp == '"') instring= !instring;
  402.                 else if (*cp == '}' || *cp == ';') inbits= instring = false;
  403.                 else if (*cp == ',') { 
  404.                         // skip rest of data in this rez.. ??
  405.                     while (*cp && !(*cp == '}' || *cp == ';')) cp++; 
  406.                     inbits= instring= false;
  407.                     } 
  408.                 
  409.                 if (atsize >= bufsize || !inbits) {
  410.                     //move buf[] data to bitmap store...
  411.                     long offset= bytesize;
  412.                     bytesize += atsize;
  413.                     if (!bitmap) 
  414.                         bitmap= (byte*) Nlm_MemGet( bytesize, false);
  415.                     else 
  416.                         bitmap= (byte*) Nlm_MemMore( bitmap, bytesize);
  417.                     Nlm_MemCopy( bitmap+offset, buf, atsize);
  418.                     bitsp= buf;
  419.                     atsize= 0;
  420.                     }
  421.                     
  422.                 if (!inbits) {                    
  423.                         // guess at width/height
  424. #if 1
  425.                     width= height= short( sqrt(bytesize * 8));
  426. #else            
  427.                         // ?? do a simple int square root -- bad for non-base-2 values
  428.                     long w= bytesize * 8;
  429.                     long h= 1;
  430.                     while (w>h) {  
  431.                         w >>= 1;
  432.                         h <<= 1;
  433.                         }
  434.                     width = w;
  435.                     height= h;
  436. #endif                    
  437.                     DIcon* ic= new DIcon( id, width, height, (const char*)bitmap, bytesize);
  438.                     this->InsertLast( ic);
  439.                     width= height= id= 0;
  440.                     bitmap= (byte*) Nlm_MemFree(bitmap);
  441.                     bitsp= NULL;
  442.                     bytesize= atsize= 0;
  443.                     inbits= instring= false;
  444.                     gotdata= true;
  445.                     *cp= 0; // done
  446.                     }
  447.                     
  448.                 }
  449.             } // end suckbits
  450.             
  451.                         
  452.         else if ( (linep= strchr(line,'{')) != NULL  && 
  453.              ( Nlm_StrngPos(line, "resource 'ICN#'", 0, true, &index)
  454.             || Nlm_StrngPos(line, "resource 'ics#'", 0, true, &index)
  455.             || Nlm_StrngPos(line, "resource 'ICON'", 0, true, &index) ) )
  456.             {
  457.             // !! get id value == first # after "("
  458.             char *nump= strchr(line,'(');
  459.             if (nump) {
  460.                 char *ep, ec;
  461.                 nump++;
  462.                 for (ep= nump; isdigit(*ep); ep++) ;
  463.                 ec= *ep; *ep= 0;
  464.                 id= atol(nump);
  465.                 *ep= ec;
  466.                 }
  467.             linep++;
  468.             inbits= true;
  469.             goto suckbits; 
  470.             }
  471.  
  472.         
  473.         }
  474.         
  475.     FileClose(f);
  476.     return gotdata;
  477. }
  478.  
  479.  
  480.  
  481. Boolean DIconList::ReadXbitmapFormat(char* filename) 
  482. {
  483. /******
  484. Xbitmap file format:
  485. #define  somename_width  16
  486. #define  somename_height 32
  487. #define  somename_bittype  x    #< optional addition to specify BitFormat
  488. static char somename [] = {            #< data starts after "{", ends after "}"
  489.    0x0f, 0xc0, 0x12, 0xff };    #< bitmap data as hex or decimal string of chars
  490. ******/
  491.     Boolean gotdata= false;
  492.     char line[512];
  493.     byte *bitsp= NULL, *bitmap = NULL;
  494.     Boolean inbits= false;
  495.     short    width = 0, height = 0;
  496.     long id = 0;
  497.     char* linep= line;
  498.     long     bytesize= 0;
  499.     long     atsize= 0;
  500.     short    bswap = 0;
  501.     BitFormat bitstype = macbits;
  502.  
  503.                 // set win system defaults -- override if file says to.
  504. #ifdef  WIN_MAC
  505.     bitstype = macbits;
  506. #endif
  507. #ifdef WIN_MSWIN
  508.     bitstype = msbits;
  509. #endif
  510. #ifdef WIN_MOTIF
  511.     bitstype = xbits;
  512. #endif
  513.  
  514.     FILE *f= FileOpen( filename, "r");
  515.     if (f) 
  516.      while (FileGets( line, 512, f)) {
  517.         // assume may be multiple bitmaps / file
  518.         linep= line;
  519.         
  520.         if (inbits) {
  521.     suckbits:            
  522.                   // data looks like: 0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00};
  523.             char* cp= linep;
  524.             if (!bitmap) {
  525.                 bytesize= height * ((width+7) / 8); // bytes/row + rowcount
  526.                 bitmap= (byte*) Nlm_MemGet( bytesize+1, false);
  527.                 bitsp= bitmap;
  528.                 }
  529.                 
  530.             while (*cp) {
  531.             
  532.                 if (*cp == '}' || *cp == ';') {
  533.                     // install data into new icon...
  534.                     *bitsp= 0; // 0 terminate? -- this isn't really useful, since bitmap can have nulls
  535.                     DIcon* ic= new DIcon( id, width, height, (const char*)bitmap, atsize);
  536.                     this->InsertLast( ic);
  537.                     width= height= id= 0;
  538.                     bitmap= (byte*) Nlm_MemFree(bitmap);
  539.                     bitsp= NULL;
  540.                     bswap= bytesize= atsize= 0;
  541.                     inbits= false;
  542.                     gotdata= true;
  543.                     *cp= 0; // done
  544.                     }
  545.                     
  546.                 else if (isdigit(*cp)) {
  547.                     short rslt= 0;
  548.                     unsigned short card= 0;
  549.                     char *fmt = "%hu";
  550.                     char ec, *ep = cp;
  551.                     Boolean okay= true;
  552.                     
  553.                     while (okay) {
  554.                         ep++;
  555.                         if (*ep == 'x' || *ep == 'X') fmt= "%hx";  
  556.                         else if (!*ep || !isalnum(*ep)) okay= false;
  557.                         }
  558.                     ec= *ep; *ep= 0;
  559.                     rslt= sscanf( cp, fmt, &card);
  560.                     *ep= ec;
  561.                     if ( atsize<bytesize && rslt>0 ) { 
  562.                         switch (bitstype) {
  563.                             case xbits: {
  564.                                 // X bitmaps have WEIRD storage format !! see Nlm_CopyBits
  565.                                 byte drac, i;
  566.                                 for (i=0, drac= 0; i<8; i++) { drac <<= 1; drac += card & 1; card >>= 1; }
  567.                                 *bitsp++ = (byte) drac;
  568.                                 }break;
  569.                             case msbits: {
  570.                                 *bitsp++ = ~(byte) card; // mswin is NOT
  571.                                 }break;
  572.                             case macbits: {
  573.                                 *bitsp++ = (byte) card;
  574.                                 }break;
  575.                             }
  576.                         atsize++;
  577.                         }
  578.                     cp = ep;
  579.                     }
  580.                     
  581.                 //else if (*cp == ',') cp++;
  582.                 else cp++; // spaces, all else...
  583.                 }
  584.             }
  585.             
  586.         else if (width && height && (linep= strchr(line,'{')) != NULL) {
  587.             linep++;
  588.             inbits= true;
  589.             goto suckbits; 
  590.             }
  591.             
  592.         else {
  593.             //look for string w/ "#define somename_width 16" << "width" is key
  594.             //or "#define somename_height 16" << "height" is key
  595.             StrPosInt index = 0;
  596.             char* cp;
  597.             if (Nlm_StrngPos(line, "width", 0, false, &index)) { //false==case-insensitive
  598.                 cp= line + index + 5; //length(width)
  599.                 while (*cp && !isdigit(*cp)) cp++;
  600.                 width= atol(cp); //?? what is better than atol()    
  601.                 }                 
  602.             else if (Nlm_StrngPos(line, "height", 0, false, &index)) {
  603.                 cp= line + index + 5;  
  604.                 while (*cp && !isdigit(*cp)) cp++;
  605.                 height= atol(cp); //?? what is better than atol()    
  606.                 }                 
  607.             else if (Nlm_StrngPos(line, "ident", 0, false, &index)) { 
  608.                 cp= line + index + 5; 
  609.                 while (*cp & !isdigit(*cp)) cp++;
  610.                 id= atol(cp);
  611.                 }                 
  612.             else if (Nlm_StrngPos(line, "bitstype", 0, false, &index)) { 
  613.                 cp= line + index + 8; 
  614.                 index= 0;
  615.                 if (Nlm_StrngPos(cp, "mac", 0, false, &index)) bitstype= macbits; 
  616.                 else if (Nlm_StrngPos(cp, "x", 0, false, &index)) bitstype= xbits; 
  617.                 else if (Nlm_StrngPos(cp, "ms", 0, false, &index)) bitstype= msbits; 
  618.                 }                 
  619.             }
  620.         
  621.         }
  622.         
  623.     FileClose(f);
  624.     return gotdata;
  625. }
  626.         
  627.  
  628.  
  629. #if 0
  630.  
  631.  
  632. // Xlibrary standard bitmap form:
  633. // (width+7) div 8 = # bytes/row
  634. #define left_ptr_width 16
  635. #define left_ptr_height 16
  636. #define left_ptr_x_hot 3
  637. #define left_ptr_y_hot 1
  638. static char left_ptr_bits[] = {
  639.    0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00,
  640.    0xf8, 0x01, 0xf8, 0x03, 0xf8, 0x07, 0xf8, 0x00, 0xd8, 0x00, 0x88, 0x01,
  641.    0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00};
  642.  
  643.   
  644. #endif
  645.